home *** CD-ROM | disk | FTP | other *** search
/ CD Actual Thematic 7: Programming / CDAT7.iso / demos / VisualAge for Java 2.0 Entry / setup / data1.cab / ide-e / IDE / cache / IYKJ7N (.txt) < prev    next >
Encoding:
Java Class File  |  1998-09-16  |  8.3 KB  |  346 lines
  1. package com.sun.java.swing;
  2.  
  3. import java.awt.Component;
  4. import java.awt.Dimension;
  5. import java.awt.Image;
  6. import java.awt.Rectangle;
  7. import java.awt.Toolkit;
  8. import java.awt.image.ImageObserver;
  9. import java.util.Enumeration;
  10. import java.util.Hashtable;
  11. import java.util.Vector;
  12.  
  13. public class RepaintManager {
  14.    WorkRequest doWorkRequest = new WorkRequest(this);
  15.    Hashtable dirtyComponents = new Hashtable();
  16.    Vector invalidComponents;
  17.    boolean doubleBufferingEnabled = true;
  18.    Image doubleBuffer;
  19.    Dimension doubleBufferMaxSize = Toolkit.getDefaultToolkit().getScreenSize();
  20.    private static final Object repaintManagerKey;
  21.    static Class class$com$sun$java$swing$RepaintManager;
  22.  
  23.    static {
  24.       Class var10000 = class$com$sun$java$swing$RepaintManager;
  25.       if (var10000 == null) {
  26.          try {
  27.             var10000 = Class.forName("com.sun.java.swing.RepaintManager");
  28.          } catch (ClassNotFoundException var0) {
  29.             throw new NoClassDefFoundError(((Throwable)var0).getMessage());
  30.          }
  31.  
  32.          class$com$sun$java$swing$RepaintManager = var10000;
  33.       }
  34.  
  35.       repaintManagerKey = var10000;
  36.    }
  37.  
  38.    public void addDirtyRegion(JComponent c, int x, int y, int w, int h) {
  39.       if (w > 0 && h > 0 && ((Component)c).isShowing()) {
  40.          synchronized(this){}
  41.  
  42.          try {
  43.             if (this.dirtyComponents == null) {
  44.                this.dirtyComponents = new Hashtable();
  45.                this.dirtyComponents.put(c, new Rectangle(x, y, w, h));
  46.             } else {
  47.                Rectangle r = (Rectangle)this.dirtyComponents.get(c);
  48.                if (r == null) {
  49.                   this.dirtyComponents.put(c, new Rectangle(x, y, w, h));
  50.                } else {
  51.                   SwingUtilities.computeUnion(x, y, w, h, r);
  52.                }
  53.             }
  54.          } catch (Throwable var9) {
  55.             throw var9;
  56.          }
  57.  
  58.          if (!this.doWorkRequest.isPending) {
  59.             this.queueWorkRequest(c);
  60.          }
  61.  
  62.       }
  63.    }
  64.  
  65.    public synchronized void addInvalidComponent(JComponent invalidComponent) {
  66.       Component validateRoot = null;
  67.  
  68.       for(Component c = invalidComponent; c != null; c = c.getParent()) {
  69.          if (c instanceof CellRendererPane) {
  70.             return;
  71.          }
  72.  
  73.          if (c instanceof JComponent && ((JComponent)c).isValidateRoot()) {
  74.             validateRoot = c;
  75.             break;
  76.          }
  77.       }
  78.  
  79.       if (validateRoot != null && validateRoot.isShowing()) {
  80.          if (this.invalidComponents == null) {
  81.             this.invalidComponents = new Vector();
  82.          } else {
  83.             int n = this.invalidComponents.size();
  84.  
  85.             for(int i = 0; i < n; ++i) {
  86.                if (validateRoot == (Component)this.invalidComponents.elementAt(i)) {
  87.                   return;
  88.                }
  89.             }
  90.          }
  91.  
  92.          this.invalidComponents.addElement(validateRoot);
  93.          if (!this.doWorkRequest.isPending) {
  94.             this.queueWorkRequest(invalidComponent);
  95.          }
  96.       }
  97.  
  98.    }
  99.  
  100.    void collectDirtyComponents(Hashtable dirtyComponents, JComponent dirtyComponent, Vector roots) {
  101.       Component rootDirtyComponent = dirtyComponent;
  102.       Component component = dirtyComponent;
  103.       Rectangle cBounds = dirtyComponent._bounds;
  104.       int rootDx = 0;
  105.       int dx = 0;
  106.       int rootDy = 0;
  107.       int dy = 0;
  108.       Rectangle tmp = new Rectangle((Rectangle)dirtyComponents.get(dirtyComponent));
  109.       SwingUtilities.computeIntersection(0, 0, cBounds.width, cBounds.height, tmp);
  110.       if (!tmp.isEmpty()) {
  111.          if (dirtyComponent.isOpaque()) {
  112.          }
  113.  
  114.          while(true) {
  115.             Component parent = ((Component)component).getParent();
  116.             if (parent == null || !(parent instanceof JComponent)) {
  117.                if (dirtyComponent != rootDirtyComponent) {
  118.                   tmp.setLocation(tmp.x + rootDx - dx, tmp.y + rootDy - dy);
  119.                   Rectangle r = (Rectangle)dirtyComponents.get(rootDirtyComponent);
  120.                   SwingUtilities.computeUnion(tmp.x, tmp.y, tmp.width, tmp.height, r);
  121.                }
  122.  
  123.                if (!roots.contains(rootDirtyComponent)) {
  124.                   roots.addElement(rootDirtyComponent);
  125.                }
  126.  
  127.                return;
  128.             }
  129.  
  130.             component = parent;
  131.             if (((JComponent)parent).isOpaque()) {
  132.             }
  133.  
  134.             dx += cBounds.x;
  135.             dy += cBounds.y;
  136.             tmp.setLocation(tmp.x + cBounds.x, tmp.y + cBounds.y);
  137.             cBounds = ((JComponent)parent)._bounds;
  138.             tmp = SwingUtilities.computeIntersection(0, 0, cBounds.width, cBounds.height, tmp);
  139.             if (tmp.isEmpty()) {
  140.                return;
  141.             }
  142.  
  143.             if (dirtyComponents.get(parent) != null) {
  144.                rootDirtyComponent = parent;
  145.                rootDx = dx;
  146.                rootDy = dy;
  147.             }
  148.          }
  149.       }
  150.    }
  151.  
  152.    public static RepaintManager currentManager(JComponent comp) {
  153.       RepaintManager result = (RepaintManager)SwingUtilities.appContextGet(repaintManagerKey);
  154.       if (result == null) {
  155.          result = new RepaintManager();
  156.          SwingUtilities.appContextPut(repaintManagerKey, result);
  157.       }
  158.  
  159.       return result;
  160.    }
  161.  
  162.    public Rectangle getDirtyRegion(JComponent aComponent) {
  163.       Rectangle r = null;
  164.       synchronized(this){}
  165.  
  166.       try {
  167.          if (this.dirtyComponents != null) {
  168.             r = (Rectangle)this.dirtyComponents.get(aComponent);
  169.          }
  170.       } catch (Throwable var5) {
  171.          throw var5;
  172.       }
  173.  
  174.       return r == null ? new Rectangle(0, 0, 0, 0) : new Rectangle(r);
  175.    }
  176.  
  177.    public Dimension getDoubleBufferMaximumSize() {
  178.       return this.doubleBufferMaxSize;
  179.    }
  180.  
  181.    public Image getOffscreenBuffer(Component c, int proposedWidth, int proposedHeight) {
  182.       int width;
  183.       if (proposedWidth > this.doubleBufferMaxSize.width) {
  184.          width = this.doubleBufferMaxSize.width;
  185.       } else {
  186.          width = proposedWidth;
  187.       }
  188.  
  189.       int height;
  190.       if (proposedHeight > this.doubleBufferMaxSize.height) {
  191.          height = this.doubleBufferMaxSize.height;
  192.       } else {
  193.          height = proposedHeight;
  194.       }
  195.  
  196.       if (this.doubleBuffer != null && (this.doubleBuffer.getWidth((ImageObserver)null) < width || this.doubleBuffer.getHeight((ImageObserver)null) < height)) {
  197.          this.doubleBuffer = null;
  198.       }
  199.  
  200.       if (this.doubleBuffer == null) {
  201.          this.doubleBuffer = c.createImage(width, height);
  202.       }
  203.  
  204.       return this.doubleBuffer;
  205.    }
  206.  
  207.    public boolean isCompletelyDirty(JComponent aComponent) {
  208.       Rectangle r = this.getDirtyRegion(aComponent);
  209.       return r.width == Integer.MAX_VALUE && r.height == Integer.MAX_VALUE;
  210.    }
  211.  
  212.    public boolean isDoubleBufferingEnabled() {
  213.       return this.doubleBufferingEnabled;
  214.    }
  215.  
  216.    public void markCompletelyClean(JComponent aComponent) {
  217.       synchronized(this){}
  218.  
  219.       try {
  220.          if (this.dirtyComponents != null) {
  221.             this.dirtyComponents.remove(aComponent);
  222.          }
  223.       } catch (Throwable var4) {
  224.          throw var4;
  225.       }
  226.  
  227.    }
  228.  
  229.    public void markCompletelyDirty(JComponent aComponent) {
  230.       this.addDirtyRegion(aComponent, 0, 0, Integer.MAX_VALUE, Integer.MAX_VALUE);
  231.    }
  232.  
  233.    public void paintDirtyRegions() {
  234.       Hashtable tmpDirtyComponents;
  235.       synchronized(this) {
  236.          if (this.dirtyComponents == null) {
  237.             return;
  238.          }
  239.  
  240.          tmpDirtyComponents = this.dirtyComponents;
  241.          this.dirtyComponents = null;
  242.       }
  243.  
  244.       int count = tmpDirtyComponents.size();
  245.       if (count != 0) {
  246.          Vector roots = new Vector(count);
  247.          Enumeration keys = tmpDirtyComponents.keys();
  248.  
  249.          while(keys.hasMoreElements()) {
  250.             JComponent dirtyComponent = (JComponent)keys.nextElement();
  251.             this.collectDirtyComponents(tmpDirtyComponents, dirtyComponent, roots);
  252.          }
  253.  
  254.          count = roots.size();
  255.  
  256.          for(int i = 0; i < count; ++i) {
  257.             JComponent var11 = (JComponent)roots.elementAt(i);
  258.             Rectangle rect = (Rectangle)tmpDirtyComponents.get(var11);
  259.             Rectangle localBounds = ((Component)var11).getBounds();
  260.             localBounds.x = localBounds.y = 0;
  261.             rect = rect.intersection(localBounds);
  262.             var11.paintImmediately(rect.x, rect.y, rect.width, rect.height);
  263.          }
  264.  
  265.       }
  266.    }
  267.  
  268.    void queueWorkRequest(JComponent target) {
  269.       if (!this.doWorkRequest.isPending) {
  270.          synchronized(this){}
  271.  
  272.          try {
  273.             this.doWorkRequest.isPending = true;
  274.             this.doWorkRequest.component = target;
  275.             SwingUtilities.invokeLater(this.doWorkRequest);
  276.          } catch (Throwable var4) {
  277.             throw var4;
  278.          }
  279.       }
  280.  
  281.    }
  282.  
  283.    public synchronized void removeInvalidComponent(JComponent component) {
  284.       if (this.invalidComponents != null) {
  285.          int index = this.invalidComponents.indexOf(component);
  286.          if (index != -1) {
  287.             this.invalidComponents.removeElementAt(index);
  288.          }
  289.       }
  290.  
  291.    }
  292.  
  293.    public static void setCurrentManager(RepaintManager aRepaintManager) {
  294.       if (aRepaintManager != null) {
  295.          SwingUtilities.appContextPut(repaintManagerKey, aRepaintManager);
  296.       } else {
  297.          SwingUtilities.appContextRemove(repaintManagerKey);
  298.       }
  299.  
  300.    }
  301.  
  302.    public void setDoubleBufferingEnabled(boolean aFlag) {
  303.       this.doubleBufferingEnabled = aFlag;
  304.       if (!this.doubleBufferingEnabled) {
  305.          this.doubleBuffer = null;
  306.       }
  307.  
  308.    }
  309.  
  310.    public void setDoubleBufferMaximumSize(Dimension d) {
  311.       this.doubleBufferMaxSize = d;
  312.       if (this.doubleBuffer != null && (this.doubleBuffer.getWidth((ImageObserver)null) > d.width || this.doubleBuffer.getHeight((ImageObserver)null) > d.height)) {
  313.          this.doubleBuffer = null;
  314.       }
  315.  
  316.    }
  317.  
  318.    public synchronized String toString() {
  319.       StringBuffer sb = new StringBuffer();
  320.       if (this.dirtyComponents != null) {
  321.          sb.append("" + this.dirtyComponents);
  322.       }
  323.  
  324.       return sb.toString();
  325.    }
  326.  
  327.    public void validateInvalidComponents() {
  328.       Vector ic;
  329.       synchronized(this) {
  330.          if (this.invalidComponents == null) {
  331.             return;
  332.          }
  333.  
  334.          ic = this.invalidComponents;
  335.          this.invalidComponents = null;
  336.       }
  337.  
  338.       int n = ic.size();
  339.  
  340.       for(int i = 0; i < n; ++i) {
  341.          ((Component)ic.elementAt(i)).validate();
  342.       }
  343.  
  344.    }
  345. }
  346.